// 聊天辅助工具类
import store from '@/store'

/**
 * 聊天辅助工具类
 * 提供统一的聊天创建和管理接口
 */
export class ChatHelper {
  
  /**
   * 创建或获取私聊
   * @param {Object} friendData - 好友数据
   * @param {string} friendData.friendId - 好友ID
   * @param {string} friendData.name - 好友名称
   * @param {string} friendData.avatar - 好友头像
   * @returns {Promise<Object>} 聊天对象
   */
  static async createOrGetPrivateChat(friendData) {
    const chatData = {
      type: 1, // 私聊
      friendId: friendData.friendId,
      name: friendData.name,
      avatar: friendData.avatar,
      remark: friendData.remark || friendData.name
    };

    try {
      // 使用 getOrCreateChat 方法
      const chat = await store.dispatch('chatList/getOrCreateChat', chatData);
      return chat;
    } catch (error) {
      console.error('创建私聊失败:', error);
      throw error;
    }
  }

  /**
   * 创建或获取群聊
   * @param {Object} groupData - 群组数据
   * @param {string} groupData.groupId - 群组ID
   * @param {string} groupData.name - 群组名称
   * @param {string} groupData.avatar - 群组头像
   * @returns {Promise<Object>} 聊天对象
   */
  static async createOrGetGroupChat(groupData) {
    const chatData = {
      type: 0, // 群聊
      groupId: groupData.groupId,
      name: groupData.name,
      avatar: groupData.avatar,
      memberCount: groupData.memberCount || 0
    };

    try {
      const chat = await store.dispatch('chatList/getOrCreateChat', chatData);
      return chat;
    } catch (error) {
      console.error('创建群聊失败:', error);
      throw error;
    }
  }

  /**
   * 检查聊天是否存在
   * @param {Object} chatData - 聊天数据
   * @returns {Object|null} 存在的聊天对象或null
   */
  static checkChatExists(chatData) {
    return store.dispatch('chatList/checkChatExists', chatData);
  }

  /**
   * 添加好友（直接调用store，不需要重复检查）
   * @param {Object} friendData - 好友数据
   * @returns {Promise<Object>} 好友对象
   */
  static async addFriend(friendData) {
    try {
      const friend = await store.dispatch('contactList/addFriend', friendData);
      return friend;
    } catch (error) {
      console.error('添加好友失败:', error);
      throw error;
    }
  }

  /**
   * 创建群组（直接调用store，不需要重复检查）
   * @param {Object} groupData - 群组数据
   * @returns {Promise<Object>} 群组对象
   */
  static async createGroup(groupData) {
    try {
      const group = await store.dispatch('groupList/createGroup', groupData);
      return group;
    } catch (error) {
      console.error('创建群组失败:', error);
      throw error;
    }
  }

  /**
   * 从好友列表创建聊天
   * @param {Object} friend - 好友对象
   * @returns {Promise<Object>} 聊天对象
   */
  static async createChatFromFriend(friend) {
    const chatData = {
      type: 1,
      friendId: friend.id,
      name: friend.name,
      avatar: friend.avatar,
      remark: friend.remark || friend.name
    };

    return await this.createOrGetPrivateChat(chatData);
  }

  /**
   * 从群组列表创建聊天
   * @param {Object} group - 群组对象
   * @returns {Promise<Object>} 聊天对象
   */
  static async createChatFromGroup(group) {
    const chatData = {
      type: 0,
      groupId: group.id,
      name: group.name,
      avatar: group.avatar,
      memberCount: group.memberCount
    };

    return await this.createOrGetGroupChat(chatData);
  }
}

// 导出默认实例
export default ChatHelper